There is also another method to solve this issue. But that will require a more involved refactor. We kind of use Pheonix live view method. We upload the files in chunks from the frontend and the backend writes those chunks to files. That will be the nuclear option that can reduce Ram a lot. I have to fully research it . It sounds possible.

Greptile Summary

This PR eliminates the peak-memory double-spike for large uploads by removing the eager BytesIO copy of every uploaded file and instead passing the original Starlette SpooledTemporaryFile reference directly to the event handler. form_data.close() is deferred to a finally block inside the _ndjson_updates streaming generator so the temp files remain alive until the handler has finished reading them, with an explicit cleanup on the error path to prevent resource leaks.

Key changes:

• file.file is now passed directly to UploadFile(...) instead of first calling await file.read() and copying into a BytesIO; peak RAM for a 4 GB upload drops from ~8 GB to ~4 GB.
• form_data.close() is deferred to a try/finally inside the streaming generator so it executes after the handler completes, not before.
• An except Exception: await form_data.close(); raise guard ensures cleanup on any error that prevents the streaming generator from ever starting.
• Tests updated to use real Starlette FormData instead of mock objects, and a new test (test_upload_file_keeps_form_open_until_stream_completes) asserts that neither file.read nor form_data.close is called until the response body is consumed.

Minor concerns:

• The existing test_upload_file constructs both UploadFile objects from the same io.BytesIO that was left at EOF after bio.write(data), so the handler silently reads empty bytes for both files. This is a pre-existing issue made more visible now that the old seek(0) on the copy is gone; a bio.seek(0) before wrapping would make the test more realistic.
• except Exception does not catch asyncio.CancelledError (a BaseException in Python ≥ 3.8), leaving a narrow window where form_data could leak if the request task is cancelled between _create_upload_event returning and the streaming generator starting.

Confidence Score: 4/5

• This PR is safe to merge with minor caveats around task-cancellation cleanup and a pre-existing test data setup issue.
• The core logic is correct: Starlette temp files are properly kept alive until the handler finishes reading them, and explicit cleanup happens in both the happy path (finally block) and the error path (except block). The only meaningful risk is a narrow resource-leak window on asyncio task cancellation that except Exception doesn't cover, plus a pre-existing test deficiency where files are read from EOF. No regressions to existing behavior are introduced.
• reflex/app.py lines 1993-1997 (except Exception cancellation gap); tests/units/test_app.py lines 958-960 (bio at EOF)

Important Files Changed

Sequence Diagram

sequenceDiagram
    participant Client
    participant UploadRoute as upload_file (Starlette route)
    participant CreateEvent as _create_upload_event()
    participant NdjsonGen as _ndjson_updates() generator
    participant Handler as State event handler
    participant FormData as form_data (Starlette temp files)

    Client->>UploadRoute: POST /upload (multipart)
    UploadRoute->>FormData: await request.form()
    FormData-->>UploadRoute: form_data (SpooledTempFile refs)

    UploadRoute->>CreateEvent: await _create_upload_event()
    CreateEvent->>FormData: form_data.getlist("files")
    Note over CreateEvent: wraps file.file directly<br/>(no BytesIO copy)
    CreateEvent-->>UploadRoute: Event(payload={files: [UploadFile(file=file.file)]})

    alt _create_upload_event raises
        UploadRoute->>FormData: await form_data.close()  [cleanup]
        UploadRoute-->>Client: raise exception
    else success
        UploadRoute-->>Client: StreamingResponse(_ndjson_updates())
        loop body_iterator consumed
            NdjsonGen->>Handler: state._process(event)
            Handler->>FormData: await file.read()  [reads temp file]
            Handler-->>NdjsonGen: state updates
            NdjsonGen-->>Client: yield update JSON
        end
        NdjsonGen->>FormData: await form_data.close()  [finally block]
        Note over FormData: SpooledTempFile deleted from disk
    end

_{Last reviewed commit: a1961f1}

Merging this PR will not alter performance

✅ 8 untouched benchmarks

_{Comparing FarhanAliRaza:memory-issue (70c199b) with main (7607fa3)}

I have fixed the reviews. _UploadStreamingResponse finally can be reverted, it will not affect 99% of request it is just extra safety.

Integration tests pass locally . The test is maybe flaky.